{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fundamentals of Python\n",
    "\n",
    "This notebook contains a small review of Python basics. We will only review several core concepts in Python with which we will be working a lot. The lecture video for this notebook will discuss some of these basics in more detail. If you are already familiar with Python, you may feel free to skip this. \n",
    "\n",
    "If you are a beginner to Python, it will be very helpful to review a more comprehensive tutorial before moving on. \n",
    "\n",
    "## Online resources for learning Python for beginners\n",
    " - [Learn Python the Hard Way](https://learnpythonthehardway.org/)\n",
    " - [Codecademy](https://www.codecademy.com/learn/learn-python)\n",
    " - [Learnpython.org](https://www.learnpython.org/)\n",
    " \n",
    "A review of core concepts in Python follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables\n",
    "\n",
    "You can assign any item in Python to a variable, to refer to or operate on later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "myVariable = 'hello world'\n",
    "print(myVariable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "We start with the most basic data containers in Python, lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# basic list in Python\n",
    "X = [2, 5, 7, -2, 0, 8, 13]\n",
    "\n",
    "# lists are 0-indexed, so index 2 is the third element in X\n",
    "print(X[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing\n",
    "\n",
    "Referring to subsets of lists (remember the 0 indexing):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5]\n",
      "[2, 5, 7, -2, 0]\n"
     ]
    }
   ],
   "source": [
    "# slicing\n",
    "y = X[0:2]\n",
    "print(y)\n",
    "y = X[:-2]  # equivalent to x[0:4] \n",
    "print(y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List operations\n",
    "\n",
    "Various methods for lists:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find index of element with value 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(X.index(7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Count number of elements in list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(len(X))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add element to the end of the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 5, 7, -2, 0, 8, 13, 99]\n"
     ]
    }
   ],
   "source": [
    "X.append(99)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insert element at index 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 55, 5, 7, -2, 0, 8, 13, 99]\n"
     ]
    }
   ],
   "source": [
    "X.insert(1, 55)\n",
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List comprehensions\n",
    "\n",
    "Convenient way in Python to make lists which are functions of other lists. Note the `**` operator is an exponent, so `x**2` means $x^2$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "New list is squares of z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 3025, 25, 49, 4, 0, 64, 169, 9801]\n"
     ]
    }
   ],
   "source": [
    "z = [x**2 for x in X]\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "New list is True/False if element is >3 or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False, True, True, True, False, False, True, True, True]\n"
     ]
    }
   ],
   "source": [
    "z = [x>3 for x in X]\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionaries (Dicts)\n",
    "\n",
    "Another way of storing data, which can be looked up using keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gene\n",
      "8\n",
      "yes, the key apples is in the dict z\n"
     ]
    }
   ],
   "source": [
    "z = {'name':'Gene', 'apples':5, 'oranges':8}\n",
    "print(z['name'])\n",
    "print(z['oranges'])\n",
    "if 'apples' in z:\n",
    "    print('yes, the key apples is in the dict z')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loops\n",
    "\n",
    "For-loops are simple, but we will learn powerful ways to avoid them with Numpy, because they are not optimized for speed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Alice\n",
      "Hi Bob\n",
      "Hi Carol\n",
      "Hi David\n"
     ]
    }
   ],
   "source": [
    "names = ['Alice', 'Bob', 'Carol', 'David']\n",
    "for name in names:\n",
    "    print('Hi %s' % name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Get a list of integers between two endpoints with `range`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(5, 9):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions\n",
    "\n",
    "A function is a reusable block of code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Alice\n",
      "Hello Bob\n"
     ]
    }
   ],
   "source": [
    "def myFunction(myArgument):\n",
    "    print('Hello '+myArgument)\n",
    "    \n",
    "myFunction('Alice')\n",
    "myFunction('Bob')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classes\n",
    "\n",
    "Classes bring object-oriented programming to Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello from ml4a!\n",
      "Hello from ml4a!\n",
      "Hello from ml4a!\n"
     ]
    }
   ],
   "source": [
    "class MyClass(object):\n",
    "    def __init__(self, message): # constructor\n",
    "        self.message = message   # assign local variable in object\n",
    "    \n",
    "    def print_message(self, n_times=2):\n",
    "        for i in range(n_times):\n",
    "            print('%s' % self.message)\n",
    "\n",
    "M = MyClass('Hello from ml4a!')\n",
    "M.print_message(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries\n",
    "\n",
    "There are many libraries avaialble for Python for various functions.\n",
    "\n",
    "Let's import two libraries: `math` and `matplotlib.pyplot` (alias to `plt`). Let's use the `math` function to calculate the cosine of 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5403023058681398\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "z = math.cos(1)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting\n",
    "\n",
    "Let's plot our sine curve. We'll be plotting a lot to make concepts more visually clear in the future."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x109130860>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10877ae48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X = [0.1*x for x in range(-50,50)]\n",
    "Y = [math.sin(x) for x in X]\n",
    "\n",
    "# make the figure\n",
    "plt.figure(figsize=(6,6))\n",
    "plt.plot(X, Y)\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y = sin(x)')\n",
    "plt.title('My plot title')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
